---
title: Overview
---

import AlphaCallout from '/snippets/alpha-lg-callout.mdx';

<AlphaCallout />

Trusted by companies shaping the future of agents - including Klarna, Replit, Elastic, and more - LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.

LangGraph is very low-level, and focused entirely on agent **orchestration**. Before using LangGraph, it is recommended you familiarize yourself with some of the components used to build agents, starting with [models](/oss/langchain/models) and [tools](/oss/langchain/tools). We will commonly use [LangChain](/oss/langchain/overview) components throughout the documentation, but you don't need to use LangChain to use LangGraph.

If you are just getting started with agents, or want a higher level abstraction, it is recommended that you use LangChain's [agents](/oss/langchain/agents).

LangGraph is focused on the underlying capabilties important for agent orchestration: durable execution, streaming, human-in-the-loop, etc. We expose two different APIs for consuming these capabilities: a Graph API and a functional API. We largely use the Graph API throughout the documentation, but feel free to use the functional API if you'd prefer.

## <Icon icon="download" size={20} /> Install

:::python
<CodeGroup>
```bash pip
pip install --pre -U langgraph
```

```bash uv
uv add --prerelease=allow langgraph
```
</CodeGroup>
:::

:::js
<CodeGroup>
```bash npm
npm install @langchain/langgraph@next @langchain/core@next
```

```bash pnpm
pnpm add @langchain/langgraph@next @langchain/core@next
```

```bash yarn
yarn add @langchain/langgraph@next @langchain/core@next
```

```bash bun
bun add @langchain/langgraph@next @langchain/core@next
```
</CodeGroup>
:::

Then, create a simple hello world example:

:::python
```python
from langgraph.graph import StateGraph, MessagesState, START, END

def mock_llm(state: MessagesState):
    return {"messages": [{"role": "ai", "content": "hello world"}]}

graph = StateGraph(MessagesState)
graph.add_node(mock_llm)
graph.add_edge(START, "mock_llm")
graph.add_edge("mock_llm", END)
graph = graph.compile()

graph.invoke({"messages": [{"role": "user", "content": "hi!"}]})
```
:::

:::js
```typescript
import { MessagesAnnotation, StateGraph, START, END } from "@langchain/langgraph";

const mockLlm = (state: typeof MessagesAnnotation.State) => {
  return { messages: [{ role: "ai", content: "hello world" }] };
};

const graph = new StateGraph(MessagesAnnotation)
  .addNode("mock_llm", mockLlm)
  .addEdge(START, "mock_llm")
  .addEdge("mock_llm", END)
  .compile();

await graph.invoke({ messages: [{ role: "user", content: "hi!" }] });
```
:::

## Core benefits

LangGraph provides low-level supporting infrastructure for *any* long-running, stateful workflow or agent. LangGraph does not abstract prompts or architecture, and provides the following central benefits:

* [Durable execution](/oss/langgraph/durable-execution): Build agents that persist through failures and can run for extended periods, resuming from where they left off.
* [Human-in-the-loop](/oss/langgraph/add-human-in-the-loop): Incorporate human oversight by inspecting and modifying agent state at any point.
* [Comprehensive memory](/oss/concepts/memory): Create stateful agents with both short-term working memory for ongoing reasoning and long-term memory across sessions.
* [Debugging with LangSmith](/langsmith/home): Gain deep visibility into complex agent behavior with visualization tools that trace execution paths, capture state transitions, and provide detailed runtime metrics.
* [Production-ready deployment](/langgraph-platform/deployment-options): Deploy sophisticated agent systems confidently with scalable infrastructure designed to handle the unique challenges of stateful, long-running workflows.

## LangGraph ecosystem

While LangGraph can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools for building agents. To improve your LLM application development, pair LangGraph with:

* [LangSmith](http://www.langchain.com/langsmith) — Helpful for agent evals and observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and improve performance over time.
* [LangGraph Platform](/langgraph-platform) — Deploy and scale agents effortlessly with a purpose-built deployment platform for long running, stateful workflows. Discover, reuse, configure, and share agents across teams — and iterate quickly with visual prototyping in [LangGraph Studio](/langgraph-platform/langgraph-studio).
* [LangChain](/oss/langchain/overview) - Provides integrations and composable components to streamline LLM application development. Contains agent abstractions built on top of LangGraph.

## Acknowledgements

LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
